#include <stdio.h>
#include <string.h>

/**************************************************************
** 函数名: des()
** 功  能: DES加解密算法
** 作  者：srh                 建立日期：20060210
** 最后修改人：                    修改日期：
** 调用其它函数：
** 全局变量：
** 参数含义: 输入:source-源数据  inkey-密钥  flg-加解密标志 0-加密  1-解密
             输出:dest-目标数据
** 返回值：0 --成功
***************************************************************/
int des(unsigned char *source, unsigned char *dest, unsigned char *inkey, int flg)
{
    unsigned char bufout[64],
        kwork[56], worka[48], kn[48], buffer[64], key[64],
        nbrofshift, temp1, temp2;
    int valindex;
    register int i, j, k, iter;

    /* INITIALIZE THE TABLES */
    /* Table - s1 */
    static unsigned char s1[4][16] =
        {
            {14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
            {0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
            {4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
            {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13}};

    /* Table - s2 */
    static unsigned char s2[4][16] =
        {
            {15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
            {3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
            {0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
            {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}};

    /* Table - s3 */
    static unsigned char s3[4][16] =
        {
            {10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
            {13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
            {13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
            {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}};

    /* Table - s4 */
    static unsigned char s4[4][16] =
        {
            {7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
            {13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
            {10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
            {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}};

    /* Table - s5 */
    static unsigned char s5[4][16] =
        {
            {2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
            {14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
            {4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
            {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}};

    /* Table - s6 */
    static unsigned char s6[4][16] =
        {
            {12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
            {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
            {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
            {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}};

    /* Table - s7 */
    static unsigned char s7[4][16] =
        {
            {4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
            {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
            {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
            {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}};

    /* Table - s8 */
    static unsigned char s8[4][16] =
        {
            {13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
            {1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
            {7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
            {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}};

    /* Table - Shift */
    static unsigned char shift[16] =
        {
            1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};

    /* Table - Binary */
    static unsigned char binary[64] =
        {
            0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1,
            0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1,
            1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1,
            1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1};

    /* MAIN PROCESS */
    /* Convert from 64-bit key into 64-byte key */
    for (i = 0; i < 8; i++)
    {
        key[8 * i] = ((j = *(inkey + i)) / 128) % 2;
        key[8 * i + 1] = (j / 64) % 2;
        key[8 * i + 2] = (j / 32) % 2;
        key[8 * i + 3] = (j / 16) % 2;
        key[8 * i + 4] = (j / 8) % 2;
        key[8 * i + 5] = (j / 4) % 2;
        key[8 * i + 6] = (j / 2) % 2;
        key[8 * i + 7] = j % 2;
    }

    /* Convert from 64-bit data into 64-byte data */
    for (i = 0; i < 8; i++)
    {
        buffer[8 * i] = ((j = *(source + i)) / 128) % 2;
        buffer[8 * i + 1] = (j / 64) % 2;
        buffer[8 * i + 2] = (j / 32) % 2;
        buffer[8 * i + 3] = (j / 16) % 2;
        buffer[8 * i + 4] = (j / 8) % 2;
        buffer[8 * i + 5] = (j / 4) % 2;
        buffer[8 * i + 6] = (j / 2) % 2;
        buffer[8 * i + 7] = j % 2;
    }

    /* Initial Permutation of Data */
    bufout[0] = buffer[57];
    bufout[1] = buffer[49];
    bufout[2] = buffer[41];
    bufout[3] = buffer[33];
    bufout[4] = buffer[25];
    bufout[5] = buffer[17];
    bufout[6] = buffer[9];
    bufout[7] = buffer[1];
    bufout[8] = buffer[59];
    bufout[9] = buffer[51];
    bufout[10] = buffer[43];
    bufout[11] = buffer[35];
    bufout[12] = buffer[27];
    bufout[13] = buffer[19];
    bufout[14] = buffer[11];
    bufout[15] = buffer[3];
    bufout[16] = buffer[61];
    bufout[17] = buffer[53];
    bufout[18] = buffer[45];
    bufout[19] = buffer[37];
    bufout[20] = buffer[29];
    bufout[21] = buffer[21];
    bufout[22] = buffer[13];
    bufout[23] = buffer[5];
    bufout[24] = buffer[63];
    bufout[25] = buffer[55];
    bufout[26] = buffer[47];
    bufout[27] = buffer[39];
    bufout[28] = buffer[31];
    bufout[29] = buffer[23];
    bufout[30] = buffer[15];
    bufout[31] = buffer[7];
    bufout[32] = buffer[56];
    bufout[33] = buffer[48];
    bufout[34] = buffer[40];
    bufout[35] = buffer[32];
    bufout[36] = buffer[24];
    bufout[37] = buffer[16];
    bufout[38] = buffer[8];
    bufout[39] = buffer[0];
    bufout[40] = buffer[58];
    bufout[41] = buffer[50];
    bufout[42] = buffer[42];
    bufout[43] = buffer[34];
    bufout[44] = buffer[26];
    bufout[45] = buffer[18];
    bufout[46] = buffer[10];
    bufout[47] = buffer[2];
    bufout[48] = buffer[60];
    bufout[49] = buffer[52];
    bufout[50] = buffer[44];
    bufout[51] = buffer[36];
    bufout[52] = buffer[28];
    bufout[53] = buffer[20];
    bufout[54] = buffer[12];
    bufout[55] = buffer[4];
    bufout[56] = buffer[62];
    bufout[57] = buffer[54];
    bufout[58] = buffer[46];
    bufout[59] = buffer[38];
    bufout[60] = buffer[30];
    bufout[61] = buffer[22];
    bufout[62] = buffer[14];
    bufout[63] = buffer[6];

    /* Initial Permutation of Key */
    kwork[0] = key[56];
    kwork[1] = key[48];
    kwork[2] = key[40];
    kwork[3] = key[32];
    kwork[4] = key[24];
    kwork[5] = key[16];
    kwork[6] = key[8];
    kwork[7] = key[0];
    kwork[8] = key[57];
    kwork[9] = key[49];
    kwork[10] = key[41];
    kwork[11] = key[33];
    kwork[12] = key[25];
    kwork[13] = key[17];
    kwork[14] = key[9];
    kwork[15] = key[1];
    kwork[16] = key[58];
    kwork[17] = key[50];
    kwork[18] = key[42];
    kwork[19] = key[34];
    kwork[20] = key[26];
    kwork[21] = key[18];
    kwork[22] = key[10];
    kwork[23] = key[2];
    kwork[24] = key[59];
    kwork[25] = key[51];
    kwork[26] = key[43];
    kwork[27] = key[35];
    kwork[28] = key[62];
    kwork[29] = key[54];
    kwork[30] = key[46];
    kwork[31] = key[38];
    kwork[32] = key[30];
    kwork[33] = key[22];
    kwork[34] = key[14];
    kwork[35] = key[6];
    kwork[36] = key[61];
    kwork[37] = key[53];
    kwork[38] = key[45];
    kwork[39] = key[37];
    kwork[40] = key[29];
    kwork[41] = key[21];
    kwork[42] = key[13];
    kwork[43] = key[5];
    kwork[44] = key[60];
    kwork[45] = key[52];
    kwork[46] = key[44];
    kwork[47] = key[36];
    kwork[48] = key[28];
    kwork[49] = key[20];
    kwork[50] = key[12];
    kwork[51] = key[4];
    kwork[52] = key[27];
    kwork[53] = key[19];
    kwork[54] = key[11];
    kwork[55] = key[3];

    /* 16 Iterations */
    for (iter = 1; iter < 17; iter++)
    {
        for (i = 0; i < 32; i++)
            buffer[i] = bufout[32 + i];

        /* Calculation of F(R, K) */
        /* Permute - E */
        worka[0] = buffer[31];
        worka[1] = buffer[0];
        worka[2] = buffer[1];
        worka[3] = buffer[2];
        worka[4] = buffer[3];
        worka[5] = buffer[4];
        worka[6] = buffer[3];
        worka[7] = buffer[4];
        worka[8] = buffer[5];
        worka[9] = buffer[6];
        worka[10] = buffer[7];
        worka[11] = buffer[8];
        worka[12] = buffer[7];
        worka[13] = buffer[8];
        worka[14] = buffer[9];
        worka[15] = buffer[10];
        worka[16] = buffer[11];
        worka[17] = buffer[12];
        worka[18] = buffer[11];
        worka[19] = buffer[12];
        worka[20] = buffer[13];
        worka[21] = buffer[14];
        worka[22] = buffer[15];
        worka[23] = buffer[16];
        worka[24] = buffer[15];
        worka[25] = buffer[16];
        worka[26] = buffer[17];
        worka[27] = buffer[18];
        worka[28] = buffer[19];
        worka[29] = buffer[20];
        worka[30] = buffer[19];
        worka[31] = buffer[20];
        worka[32] = buffer[21];
        worka[33] = buffer[22];
        worka[34] = buffer[23];
        worka[35] = buffer[24];
        worka[36] = buffer[23];
        worka[37] = buffer[24];
        worka[38] = buffer[25];
        worka[39] = buffer[26];
        worka[40] = buffer[27];
        worka[41] = buffer[28];
        worka[42] = buffer[27];
        worka[43] = buffer[28];
        worka[44] = buffer[29];
        worka[45] = buffer[30];
        worka[46] = buffer[31];
        worka[47] = buffer[0];

        /* KS Function Begin */
        if (flg)
        {
            nbrofshift = shift[iter - 1];
            for (i = 0; i < (int)nbrofshift; i++)
            {
                temp1 = kwork[0];
                temp2 = kwork[28];
                for (j = 0; j < 27; j++)
                {
                    kwork[j] = kwork[j + 1];
                    kwork[j + 28] = kwork[j + 29];
                }
                kwork[27] = temp1;
                kwork[55] = temp2;
            }
        }
        else if (iter > 1)
        {
            nbrofshift = shift[17 - iter];
            for (i = 0; i < (int)nbrofshift; i++)
            {
                temp1 = kwork[27];
                temp2 = kwork[55];
                for (j = 27; j > 0; j--)
                {
                    kwork[j] = kwork[j - 1];
                    kwork[j + 28] = kwork[j + 27];
                }
                kwork[0] = temp1;
                kwork[28] = temp2;
            }
        }

        /* Permute kwork - PC2 */
        kn[0] = kwork[13];
        kn[1] = kwork[16];
        kn[2] = kwork[10];
        kn[3] = kwork[23];
        kn[4] = kwork[0];
        kn[5] = kwork[4];
        kn[6] = kwork[2];
        kn[7] = kwork[27];
        kn[8] = kwork[14];
        kn[9] = kwork[5];
        kn[10] = kwork[20];
        kn[11] = kwork[9];
        kn[12] = kwork[22];
        kn[13] = kwork[18];
        kn[14] = kwork[11];
        kn[15] = kwork[3];
        kn[16] = kwork[25];
        kn[17] = kwork[7];
        kn[18] = kwork[15];
        kn[19] = kwork[6];
        kn[20] = kwork[26];
        kn[21] = kwork[19];
        kn[22] = kwork[12];
        kn[23] = kwork[1];
        kn[24] = kwork[40];
        kn[25] = kwork[51];
        kn[26] = kwork[30];
        kn[27] = kwork[36];
        kn[28] = kwork[46];
        kn[29] = kwork[54];
        kn[30] = kwork[29];
        kn[31] = kwork[39];
        kn[32] = kwork[50];
        kn[33] = kwork[44];
        kn[34] = kwork[32];
        kn[35] = kwork[47];
        kn[36] = kwork[43];
        kn[37] = kwork[48];
        kn[38] = kwork[38];
        kn[39] = kwork[55];
        kn[40] = kwork[33];
        kn[41] = kwork[52];
        kn[42] = kwork[45];
        kn[43] = kwork[41];
        kn[44] = kwork[49];
        kn[45] = kwork[35];
        kn[46] = kwork[28];
        kn[47] = kwork[31];
        /* KS Function End */

        /* worka XOR kn */
        for (i = 0; i < 48; i++)
        {
            worka[i] = worka[i] ^ kn[i];
        }

        /* 8 s-functions */
        valindex = s1[2 * worka[0] + worka[5]]
                     [2 * (2 * (2 * worka[1] + worka[2]) +
                           worka[3]) +
                      worka[4]];
        valindex = valindex * 4;
        kn[0] = binary[0 + valindex];
        kn[1] = binary[1 + valindex];
        kn[2] = binary[2 + valindex];
        kn[3] = binary[3 + valindex];
        valindex = s2[2 * worka[6] + worka[11]]
                     [2 * (2 * (2 * worka[7] + worka[8]) +
                           worka[9]) +
                      worka[10]];
        valindex = valindex * 4;
        kn[4] = binary[0 + valindex];
        kn[5] = binary[1 + valindex];
        kn[6] = binary[2 + valindex];
        kn[7] = binary[3 + valindex];
        valindex = s3[2 * worka[12] + worka[17]]
                     [2 * (2 * (2 * worka[13] + worka[14]) +
                           worka[15]) +
                      worka[16]];
        valindex = valindex * 4;
        kn[8] = binary[0 + valindex];
        kn[9] = binary[1 + valindex];
        kn[10] = binary[2 + valindex];
        kn[11] = binary[3 + valindex];
        valindex = s4[2 * worka[18] + worka[23]]
                     [2 * (2 * (2 * worka[19] + worka[20]) +
                           worka[21]) +
                      worka[22]];
        valindex = valindex * 4;
        kn[12] = binary[0 + valindex];
        kn[13] = binary[1 + valindex];
        kn[14] = binary[2 + valindex];
        kn[15] = binary[3 + valindex];
        valindex = s5[2 * worka[24] + worka[29]]
                     [2 * (2 * (2 * worka[25] + worka[26]) +
                           worka[27]) +
                      worka[28]];
        valindex = valindex * 4;
        kn[16] = binary[0 + valindex];
        kn[17] = binary[1 + valindex];
        kn[18] = binary[2 + valindex];
        kn[19] = binary[3 + valindex];
        valindex = s6[2 * worka[30] + worka[35]]
                     [2 * (2 * (2 * worka[31] + worka[32]) +
                           worka[33]) +
                      worka[34]];
        valindex = valindex * 4;
        kn[20] = binary[0 + valindex];
        kn[21] = binary[1 + valindex];
        kn[22] = binary[2 + valindex];
        kn[23] = binary[3 + valindex];
        valindex = s7[2 * worka[36] + worka[41]]
                     [2 * (2 * (2 * worka[37] + worka[38]) +
                           worka[39]) +
                      worka[40]];
        valindex = valindex * 4;
        kn[24] = binary[0 + valindex];
        kn[25] = binary[1 + valindex];
        kn[26] = binary[2 + valindex];
        kn[27] = binary[3 + valindex];
        valindex = s8[2 * worka[42] + worka[47]]
                     [2 * (2 * (2 * worka[43] + worka[44]) +
                           worka[45]) +
                      worka[46]];
        valindex = valindex * 4;
        kn[28] = binary[0 + valindex];
        kn[29] = binary[1 + valindex];
        kn[30] = binary[2 + valindex];
        kn[31] = binary[3 + valindex];

        /* Permute - P */
        worka[0] = kn[15];
        worka[1] = kn[6];
        worka[2] = kn[19];
        worka[3] = kn[20];
        worka[4] = kn[28];
        worka[5] = kn[11];
        worka[6] = kn[27];
        worka[7] = kn[16];
        worka[8] = kn[0];
        worka[9] = kn[14];
        worka[10] = kn[22];
        worka[11] = kn[25];
        worka[12] = kn[4];
        worka[13] = kn[17];
        worka[14] = kn[30];
        worka[15] = kn[9];
        worka[16] = kn[1];
        worka[17] = kn[7];
        worka[18] = kn[23];
        worka[19] = kn[13];
        worka[20] = kn[31];
        worka[21] = kn[26];
        worka[22] = kn[2];
        worka[23] = kn[8];
        worka[24] = kn[18];
        worka[25] = kn[12];
        worka[26] = kn[29];

        worka[27] = kn[5];
        worka[28] = kn[21];
        worka[29] = kn[10];
        worka[30] = kn[3];
        worka[31] = kn[24];

        /* bufout XOR worka */
        for (i = 0; i < 32; i++)
        {
            bufout[i + 32] = bufout[i] ^ worka[i];
            bufout[i] = buffer[i];
        }
    } /* End of Iter */

    /* Prepare Output */
    for (i = 0; i < 32; i++)
    {
        j = bufout[i];
        bufout[i] = bufout[32 + i];
        bufout[32 + i] = j;
    }

    /* Inverse Initial Permutation */
    buffer[0] = bufout[39];
    buffer[1] = bufout[7];
    buffer[2] = bufout[47];
    buffer[3] = bufout[15];
    buffer[4] = bufout[55];
    buffer[5] = bufout[23];
    buffer[6] = bufout[63];
    buffer[7] = bufout[31];
    buffer[8] = bufout[38];
    buffer[9] = bufout[6];
    buffer[10] = bufout[46];
    buffer[11] = bufout[14];
    buffer[12] = bufout[54];
    buffer[13] = bufout[22];
    buffer[14] = bufout[62];
    buffer[15] = bufout[30];
    buffer[16] = bufout[37];
    buffer[17] = bufout[5];
    buffer[18] = bufout[45];
    buffer[19] = bufout[13];
    buffer[20] = bufout[53];
    buffer[21] = bufout[21];
    buffer[22] = bufout[61];
    buffer[23] = bufout[29];
    buffer[24] = bufout[36];
    buffer[25] = bufout[4];
    buffer[26] = bufout[44];
    buffer[27] = bufout[12];
    buffer[28] = bufout[52];
    buffer[29] = bufout[20];
    buffer[30] = bufout[60];
    buffer[31] = bufout[28];
    buffer[32] = bufout[35];
    buffer[33] = bufout[3];
    buffer[34] = bufout[43];
    buffer[35] = bufout[11];
    buffer[36] = bufout[51];
    buffer[37] = bufout[19];
    buffer[38] = bufout[59];
    buffer[39] = bufout[27];
    buffer[40] = bufout[34];
    buffer[41] = bufout[2];
    buffer[42] = bufout[42];
    buffer[43] = bufout[10];
    buffer[44] = bufout[50];
    buffer[45] = bufout[18];
    buffer[46] = bufout[58];
    buffer[47] = bufout[26];
    buffer[48] = bufout[33];
    buffer[49] = bufout[1];
    buffer[50] = bufout[41];
    buffer[51] = bufout[9];
    buffer[52] = bufout[49];
    buffer[53] = bufout[17];
    buffer[54] = bufout[57];
    buffer[55] = bufout[25];
    buffer[56] = bufout[32];
    buffer[57] = bufout[0];
    buffer[58] = bufout[40];
    buffer[59] = bufout[8];
    buffer[60] = bufout[48];
    buffer[61] = bufout[16];
    buffer[62] = bufout[56];
    buffer[63] = bufout[24];

    j = 0;
    for (i = 0; i < 8; i++)
    {
        *(dest + i) = 0x00;
        for (k = 0; k < 7; k++)
            *(dest + i) = ((*(dest + i)) + buffer[j + k]) * 2;
        *(dest + i) = *(dest + i) + buffer[j + 7];
        j += 8;
    }

    return 0;
}
